#!/usr/bin/env python
# -*- coding: utf-8 -*-

from GladeConnect import GladeConnect
import gtk
import sys
import time
import datetime
import dialogos
import debugwindow
import SimpleTree
import ifd
import completion
import comunes
import proceso
from psycopg2 import connect
from strSQL.basicas import strSelectDespacho
from strSQL.basicas import strNextValCodigo
from pyBusqueda import pyBusqueda
import printDespacho

(CODIGO_DESPACHO,
 CODIGO_TIPO_DOCUMENTO,
 DESCRIPCION_DOCUMENTO,
 NUMERO_DOCUMENTO,
 FECHA_DESPACHO,
 HORA_DESPACHO,
 RUT_CLIENTE,
 NOMBRE_CLIENTE,
 RUT_TRANSPORTISTA,
 NOMBRE_TRANSPORTISTA,
 DESTINO,
 OBSERVACIONES,
 SELLO,
 CODIGO_TEMPORADA,
 DESCRIPCION_TEMPORADA) = range(15)

class wnDespacho(GladeConnect):
    def __init__(self, conexion=None, padre=None, root="wnDespacho"):
        GladeConnect.__init__(self, "glade/wnDespacho.glade", root)
        self.cnx = conexion
        self.cursor = self.cnx.cursor()
        self.padre = padre
        if padre is None :
            self.wnDespacho.maximize()
            self.frm_padre = self.wnDespacho
            self.padre 
        else:
            self.frm_padre = padre.frm_padre
        
        self.crea_columnas()
    
    def crea_columnas(self):
        columnas = []
        columnas.append ([CODIGO_DESPACHO, "Código", "int"])
        columnas.append ([DESCRIPCION_DOCUMENTO, "Tipo Documento", "str"])
        columnas.append ([NUMERO_DOCUMENTO, "Número Documento", "str"])
        columnas.append ([FECHA_DESPACHO, "Fecha Despacho", "dte"])
        columnas.append ([HORA_DESPACHO, "Hora Despacho", "str"])
        columnas.append ([NOMBRE_CLIENTE, "Cliente", "str"])
        columnas.append ([DESTINO, "Destino Despacho", "str"])
        columnas.append ([DESCRIPCION_TEMPORADA, "Temporada", "str"])
        
        self.carga_datos()
        SimpleTree.GenColsByModel(self.modelo, columnas, self.treeDespacho)
      
    def on_btnImprimir_clicked(self, btn=None):
        model, it = self.treeDespacho.get_selection().get_selected()
        if model is None or it is None:
            dialogos.error('<b>Debe Seleccionar el Despacho que Desea Imprimir</b>')
            return
        codigo = model.get_value(it, CODIGO_DESPACHO)
        t = printDespacho.DespachoHTML(self.cnx, model, it)
        t.show()  
      
    def carga_datos(self):
        self.modelo = ifd.ListStoreFromSQL(self.cnx, strSelectDespacho)
        self.treeDespacho.set_model(self.modelo)
        
    def on_treeProceso_row_activated(self, tree=None, path=None, col=None):
        self.on_btnPropiedades_clicked()
        
    def on_btnAnadir_clicked(self, btn=None, data=None):
        dlg = dlgDespacho(self.cnx, self.frm_padre, False)
        hora = str(time.localtime()[3]).zfill(2)
        minuto = str(time.localtime()[4]).zfill(2)
        dlg.entFecha.set_date(datetime.date.today())
        dlg.entHora.set_text("%s:%s"%(hora,minuto))
        dlg.editando = False
        response = dlg.dlgDespacho.run()
        if response == gtk.RESPONSE_OK:
            self.carga_datos()
        
    def on_btnQuitar_clicked(self, btn=None):
        model, it = self.treeDespacho.get_selection().get_selected()
        if model is None or it is None:
            return
        codigo = model.get_value(it, CODIGO_DESPACHO)
        numero_documento = model.get_value(it, NUMERO_DOCUMENTO)
        rut_cliente = model.get_value(it, RUT_CLIENTE)
        
        if dialogos.yesno("¿Desea eliminar el Despacho <b>%s, del proveedor %s que recibe el documento %s</b>?\nEsta acción no se puede deshacer\n" % (codigo, rut_cliente, numero_documento), self.frm_padre) == gtk.RESPONSE_YES:
            llaves = {'codigo_despacho':codigo}
            sql = ifd.deleteFromDict('traza.despacho', llaves)
            try:
                self.cursor.execute(sql, llaves)
                model.remove(it)
            except:
                print sys.exc_info()[1]
                dialogos.error("<b>NO SE PUEDE ELIMINAR</b>")
                
            
    def on_btnPropiedades_clicked(self, btn=None):
        model, it = self.treeDespacho.get_selection().get_selected()
        if model is None or it is None:
            return
        
        dlg = dlgDespacho(self.cnx, self.frm_padre, False, codigo_despacho=model.get_value(it, CODIGO_DESPACHO))
        dlg.entCodigoDespacho.set_text(model.get_value(it, CODIGO_DESPACHO))
        dlg.codigo_tipo_documento = dlg.pecTipoDocumento.select(model.get_value(it, DESCRIPCION_DOCUMENTO), 1)
        dlg.entNumero.set_text(model.get_value(it, NUMERO_DOCUMENTO))
        
        fecha = comunes.GetDateFromModel(model.get_value(it, FECHA_DESPACHO).split()[0])
        
        dlg.entFecha.set_date(fecha)
        dlg.entHora.set_text(model.get_value(it, HORA_DESPACHO))
        
        dlg.rut_transportista = dlg.pecTransporte.select(model.get_value(it, NOMBRE_TRANSPORTISTA), 1)
        dlg.rut_cliente = dlg.pecCliente.select(model.get_value(it, NOMBRE_CLIENTE), 1)
        dlg.entDestino.set_text(model.get_value(it, DESTINO))
        dlg.entSello.set_text(model.get_value(it, SELLO))
        
        buf = dlg.txtObservaciones.get_buffer()
        texto = ""
        if len(model[0]) > OBSERVACIONES:
            texto = model.get_value(it, OBSERVACIONES)

        if texto is None:
            texto = ""
        buf.set_text(texto)
        dlg.txtObservaciones.set_buffer(buf)
        
        dlg.entTemporada.set_text(model.get_value(it, DESCRIPCION_TEMPORADA))
        dlg.codigo_temporada = model.get_value(it, CODIGO_TEMPORADA)
        dlg.pecTemporada.set_selected(True)
        
        dlg.aplicacion.carga_modelo(model.get_value(it, CODIGO_DESPACHO), "despacho")
        dlg.control.carga_modelo(model.get_value(it, CODIGO_DESPACHO), "despacho")
        
        dlg.editando = True
        
        response = dlg.dlgDespacho.run()
        if response == gtk.RESPONSE_OK:
            self.modelo.clear()
            self.carga_datos()

    def on_btnCerrar_clicked(self, btn=None):
        if self.padre is None:
            self.on_exit()
        else:
            self.padre.remove_tab("Despacho")
            
    def on_treeDespacho_row_activated(self, tree=None, path=None, col=None):
        self.on_btnPropiedades_clicked()

class dlgDespacho(GladeConnect):
    def __init__(self, conexion=None, padre=None, editando=None, codigo_despacho=None):
        GladeConnect.__init__(self, "glade/wnProceso.glade", "dlgDespacho")
        self.cnx = conexion
        self.cursor = self.cnx.cursor()
        self.editando = editando
        self.entDocumento.grab_focus()
        self.frm_padre = padre
        self.codigo_tipo_documento = None
        self.rut_cliente = None
        self.rut_transportista = None
        self.dlgDespacho.show_all()
        
        self.aplicacion = proceso.vboxAplicacion(self.cnx, self)
        self.ntbDespacho.append_page(self.aplicacion.vboxAplicacion, gtk.Label("Insumos"))
        
        self.control = proceso.vboxControl(self.cnx, self)
        self.ntbDespacho.append_page(self.control.vboxControl, gtk.Label("Control"))
        
        self.Embotellado = proceso.vboxDespachoEmbotellado(self.cnx, self, codigo_despacho)
        self.Embotellado.label2.set_text("Cantidad de botellas")
        self.Embotellado.label5.unset_flags(gtk.MAPPED)
        self.Embotellado.spnPorcentaje.unset_flags(gtk.MAPPED)
        self.ntbDespacho.append_page(self.Embotellado.vboxTipoDespacho, gtk.Label("Embotellado"))
         
        self.Mezcla = proceso.vboxDespachoMezcla(self.cnx,self, codigo_despacho)
        self.Mezcla.label2.set_text("Volumen")
        self.ntbDespacho.append_page(self.Mezcla.vboxTipoDespacho, gtk.Label("Mezclas"))
        
        self.pecTipoDocumento = completion.CompletionTipoDocumento(self.entDocumento,
                self.sel_tipo_documento,
                self.cnx)

        self.pecCliente = completion.CompletionCliente(self.entCliente,
                self.sel_rut,
                self.cnx)
    
        self.pecTransporte = completion.CompletionTransporte(self.entTransporte,
                self.sel_transportista,
                self.cnx)
        
        self.pecTemporada = completion.CompletionTemporada(self.entTemporada,
                self.sel_temporada,
                self.cnx)
        
        #<CODIGO comment="PARA SUGERIR LA MAS NUEVA">
        strSelectCodigoTemporada = """SELECT
                                        codigo_temporada,
                                        'Temporada ' || date_part('year', fecha_inicio) || '-' 
                                        || date_part('year', fecha_termino) as descripcion_temporada
                                        FROM traza.temporada
                                        WHERE abierta = TRUE
                                        ORDER BY codigo_temporada desc"""
                                        
        m = ifd.ListStoreFromSQL(self.cnx, strSelectCodigoTemporada)
        self.codigo_temporada = m[0][0]
        self.entTemporada.set_text(m[0][1])
        self.pecTemporada.set_selected(True)
        #</CODIGO>
        
        self.dlgDespacho.show_all()
    
    def sel_tipo_documento(self, completion, model, it):
        self.codigo_tipo_documento = model.get_value(it, 1)
    
    def sel_rut(self, completion, model, it):
        self.rut_cliente = model.get_value(it, 1)
    
    def sel_transportista(self, completion, model, it):
        self.rut_transportista = model.get_value(it, 1)
        
    def sel_temporada(self, completion, model, iter):
        self.codigo_temporada = model.get_value(iter, 1)
    
    def on_btnAceptar_clicked(self, btn=None):
        fecha_despacho = self.entFecha.get_date()
        hora = self.entHora.get_text()
        
        if self.entTemporada.get_text() == "":
            dialogos.error("La temporada no puede ser vacia.")
            return
        
        campos = {}
        llaves = {}
        campos['codigo_tipo_documento']  = self.codigo_tipo_documento
        campos['numero_documento']  = self.entNumero.get_text()
        campos['fecha_despacho'] = fecha_despacho.strftime("%Y/%m/%d")
        campos['hora_despacho'] = hora
        campos['rut_cliente']  = self.rut_cliente
        campos['destino']  = self.entDestino.get_text().upper()
        campos['sello_seguridad']  = self.entSello.get_text().upper()
        campos['rut_transportista']  = self.rut_transportista
        campos['codigo_temporada'] = self.codigo_temporada
        
        buf = self.txtObservaciones.get_buffer()
        s, e = buf.get_bounds()
        if str(buf.get_text(s, e)) != "None" and str(buf.get_text(s, e)) != "":
            campos['observaciones'] = buf.get_text(s, e)
        else:
            buf.set_text("")
            campos['observaciones'] = buf.get_text(s, e)
            
        self.cursor.execute("BEGIN")
        
        try:
            if not self.editando:
                self.cursor.execute(strNextValCodigo % ("despacho", "despacho"))
                reg = self.cursor.fetchone()
                campos['codigo_despacho'] = reg[0]
                llaves['codigo_despacho'] = reg[0]
                sql = ifd.insertFromDict("traza.despacho", campos)
            else:
                llaves['codigo_despacho'] = self.entCodigoDespacho.get_text()
                sql, campos=ifd.updateFromDict("traza.despacho", campos, llaves)
            
            self.cursor.execute(sql, campos)
            self.aplicacion.guarda_modelo(llaves['codigo_despacho'], "despacho")
            self.control.guarda_modelo(llaves['codigo_despacho'], "despacho")
            self.Embotellado.guarda_despacho("traza.embotellado_despacho", "codigo_despacho", llaves['codigo_despacho'], "codigo_embotellado")
            self.Mezcla.guarda_despacho("traza.mezcla_despacho", "codigo_despacho", llaves['codigo_despacho'], "codigo_mezcla")
        except:
            txt_error = sys.exc_info()[1]
            self.cursor.execute("ROLLBACK")
            dialogos.error("Ha ocurrido un error al intentar registrar los datos", str(txt_error))
            return
        
        self.cursor.execute("COMMIT")
        
        self.dlgDespacho.hide()
        
    def on_btnCancelar_clicked(self, btn=None):
        self.dlgDespacho.hide()
    
if __name__ == '__main__':
    cnx = connect("dbname=traza user=traza password=123 host=localhost")
    #cnx.autocommit()
    sys.excepthook = debugwindow.show
    d = wnDespacho(cnx)
    
    gtk.main()
